bin/detect-port.ts (1)

Line range hint 49-49: Replace isNaN with Number.isNaN for more accurate checks that avoid type coercion.

- } else if (isNaN(port)) {
+ } else if (Number.isNaN(port)) {

src/detect-port.ts (1)

Line range hint 19-47: Refactor to avoid reassigning function parameters.

Reassigning function parameters can lead to confusing bugs and harder-to-maintain code. Consider using local variables instead.

- export default function detectPort(port?: number | string | PortConfig | DetectPortCallback, callback?: DetectPortCallback) {
+ export default function detectPort(inputPort?: number | string | PortConfig | DetectPortCallback, inputCallback?: DetectPortCallback) {
+   let port = inputPort;
+   let callback = inputCallback;

Configuration used: CodeRabbit UI
Review profile: CHILL

src/detect-port.ts (1)

94-94: Fix typographical error in the comment.

In the comment, correct the word "unkonwn" to "unknown" for proper spelling.

src/wait-port.ts (1)

6-6: Use built-in setTimeout from node:timers/promises instead of custom sleep function.

Node.js 16+ provides a Promise-based setTimeout in node:timers/promises, which simplifies the code and removes the need for a custom sleep function.

Apply this diff to refactor:

- const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+ import { setTimeout as sleep } from 'node:timers/promises';

test/wait-port.test.ts (2)

13-13: Improve test case description for clarity.

The test description 'should be work' is grammatically incorrect. Consider rephrasing it to 'should work' or 'should wait for the port successfully'.

Apply this diff to update the test description:

- it('should be work', async () => {
+ it('should wait for the port successfully', async () => {

---

25-25: Improve test case description for clarity.

The test description 'should be work when retries exceeded' is unclear. Rephrase it to 'should throw an error when retries are exceeded' for better understanding.

Apply this diff to update the test description:

- it('should be work when retries exceeded', async () => {
+ it('should throw an error when retries are exceeded', async () => {

bin/detect-port.cjs (2)

Line range hint 36-44: Consider adding error handling for the callback

The error handling in the callback could be improved to ensure proper process exit codes on errors.

 detectPort(random, (err, port) => {
   if (isVerbose) {
     if (err) {
       console.log(`get available port failed with ${err}`);
+      process.exit(1);
     }
     console.log(`get available port ${port} randomly`);
   } else {
     console.log(port || random);
   }
 });

---

Line range hint 65-80: Consider modernizing the callback pattern

Since this PR requires Node.js 16+, consider using async/await pattern for better readability and error handling.

-  detectPort(port, (err, _port) => {
+  (async () => {
+    try {
+      const _port = await detectPort(port);
       if (isVerbose) {
-        if (err) {
-          console.log(`get available port failed with ${err}`);
-        }
         if (port !== _port) {
           console.log(`port ${port} was occupied`);
         }
         console.log(`get available port ${_port}`);
       } else {
         console.log(_port || port);
       }
-    });
+    } catch (err) {
+      if (isVerbose) {
+        console.log(`get available port failed with ${err}`);
+      }
+      process.exit(1);
+    }
+  })();

test/cli.test.ts (1)

34-38: Uncomment and fix the random port test

The commented test for random port output should either be removed or uncommented and fixed. If it's meant to be skipped temporarily, add a TODO comment explaining why.

README.md (1)

Line range hint 41-60: Add ESM import example alongside CommonJS

Since the package now supports both ESM and CJS, the documentation should show both import styles.

Add ESM example:

 ```javascript
 const detect = require('detect-port');
 /**
  * use as a promise
  */
+```
+
+```javascript
+// ESM
+import detect from 'detect-port';
+```

CHANGELOG.md (1)

75-75: Fix hyphenation in changelog entry

The term "double check" should be hyphenated as "double-check" for grammatical correctness.

- * fix: should double check 0.0.0.0 and localhost (#20)
+ * fix: should double-check 0.0.0.0 and localhost (#20)

🧰 Tools

🪛 LanguageTool

[grammar] ~75-~75: The verb “double-check” is spelled with a hyphen.
Context: ...-11 ================== * fix: should double check 0.0.0.0 and localhost (#20) * docs: i...

(DOUBLE_HYPHEN)

🪛 Markdownlint (0.35.0)

75-75: Expected: 0; Actual: 2
Unordered list indentation

(MD007, ul-indent)

Configuration used: CodeRabbit UI
Review profile: CHILL

+ interface RetryError extends Error {
+   retries: number;
+   count: number;
+ }
- const err = new Error('retries exceeded');
- (err as any).retries = retries;
- (err as any).count = count;
+ const err: RetryError = new Error('retries exceeded') as RetryError;
+ err.retries = retries;
+ err.count = count;

- servers.forEach(server => server.close());
+ for (const server of servers) {
+   server.close();
+ }

- } catch (err:any) {
+ } catch (err: Error) {

- const res = await execaNode(binFile, [ givenPort + '' ]);
+ const res = await execaNode(binFile, [ `${givenPort}` ]);

- it('work with listening next port 24001 because 24000 was listened to ' + ip(), async () => {
+ it(`work with listening next port 24001 because 24000 was listened to ${ip()}`, async () => {

- after(() => {
-   servers.forEach(server => server.close());
- });
+ after(async () => {
+   await Promise.all(
+     servers.map(server => 
+       new Promise<void>((resolve, reject) => {
+         server.close(err => err ? reject(err) : resolve());
+       })
+     )
+   );
+ });

package.json (1)

28-28: Consider using a lower @types/node version

The current @types/node version (^22.10.1) is unnecessarily high for Node.js 16+ support. Consider using a version that matches your minimum Node.js version requirement.

-    "@types/node": "^22.10.1",
+    "@types/node": "^16.18.0",

src/bin/detect-port.ts (2)

Line range hint 18-25: Consider using filter for array manipulation

The current implementation mutates the array and uses a loop with splice. Consider using filter for a more functional and efficient approach.

-const removeByValue = (arr: string[], val: string) => {
-  for (let i = 0; i < arr.length; i++) {
-    if (arr[i] === val) {
-      arr.splice(i, 1);
-      break;
-    }
-  }
-};
+const removeByValue = (arr: string[], val: string): string[] => {
+  return arr.filter(item => item !== val);
+};

---

Line range hint 35-77: Consider modernizing with async/await

The callback-based error handling could be modernized using async/await for better readability and error handling.

Example transformation:

try {
  const _port = await detectPort(port);
  if (isVerbose) {
    if (port !== _port) {
      console.log(`port ${port} was occupied`);
    }
    console.log(`get available port ${_port}`);
  } else {
    console.log(_port || port);
  }
} catch (err) {
  if (isVerbose) {
    console.log(`get available port failed with ${err}`);
  }
  process.exit(1);
}

Configuration used: CodeRabbit UI
Review profile: CHILL